---

yaml
---
r: 173166
b: refs/heads/snap-stage3
c: 2c76710
h: refs/heads/master
v: v3

Author: eddyb

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 896cb36ecab3eaeb7f101087e030e43771eca5ca
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e7b397b02e49ab6af5bc2a30dd04c19c38e0e266
+refs/heads/snap-stage3: 2c76710ecedb459d36ae110882931143a6fd5dd1
 refs/heads/try: 957472483d3a2f43c0e4f7c2056280a1022af93c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/libcollections/dlist.rs

@@ -221,12 +221,9 @@ impl<T> DList<T> {
         DList{list_head: None, list_tail: Rawlink::none(), length: 0}
     }
 
-    /// Moves all elements from `other` to the end of the list.
+    /// Adds all elements from `other` to the end of the list.
     ///
-    /// This reuses all the nodes from `other` and moves them into `self`. After
-    /// this operation, `other` becomes empty.
-    ///
-    /// This operation should compute in O(1) time and O(1) memory.
+    /// This operation should compute in O(1) time.
     ///
     /// # Examples
     ///
@@ -240,20 +237,16 @@ impl<T> DList<T> {
     /// b.push_back(3i);
     /// b.push_back(4);
     ///
-    /// a.append(&mut b);
+    /// a.append(b);
     ///
     /// for e in a.iter() {
     ///     println!("{}", e); // prints 1, then 2, then 3, then 4
     /// }
-    /// println!("{}", b.len()); // prints 0
     /// ```
-    pub fn append(&mut self, other: &mut DList<T>) {
+    #[unstable = "append should be by-mutable-reference"]
+    pub fn append(&mut self, mut other: DList<T>) {
         match self.list_tail.resolve() {
-            None => {
-                self.length = other.length;
-                self.list_head = other.list_head.take();
-                self.list_tail = other.list_tail.take();
-            },
+            None => *self = other,
             Some(tail) => {
                 // Carefully empty `other`.
                 let o_tail = other.list_tail.take();
@@ -268,7 +261,6 @@ impl<T> DList<T> {
                 }
             }
         }
-        other.length = 0;
     }
 
     /// Provides a forward iterator.
@@ -412,51 +404,6 @@ impl<T> DList<T> {
     pub fn pop_back(&mut self) -> Option<T> {
         self.pop_back_node().map(|box Node{value, ..}| value)
     }
-
-    /// Splits the list into two at the given index. Returns everything after the given index,
-    /// including the index.
-    ///
-    /// This operation should compute in O(n) time.
-    #[stable]
-    pub fn split_off(&mut self, at: uint) -> DList<T> {
-        let len = self.len();
-        assert!(at < len, "Cannot split off at a nonexistent index");
-        if at == 0 {
-            return mem::replace(self, DList::new());
-        }
-
-        // Below, we iterate towards the `i-1`th node, either from the start or the end,
-        // depending on which would be faster.
-        let mut split_node = if at - 1 <= len - 1 - (at - 1) {
-            let mut iter = self.iter_mut();
-            // instead of skipping using .skip() (which creates a new struct),
-            // we skip manually so we can access the head field without
-            // depending on implementation details of Skip
-            for _ in range(0, at - 1) {
-                iter.next();
-            }
-            iter.head
-        }  else {
-            // better off starting from the end
-            let mut iter = self.iter_mut();
-            for _ in range(0, len - 1 - (at - 1)) {
-                iter.next_back();
-            }
-            iter.tail
-        };
-
-        let mut splitted_list = DList {
-            list_head: None,
-            list_tail: self.list_tail,
-            length: len - at
-        };
-
-        mem::swap(&mut split_node.resolve().unwrap().next, &mut splitted_list.list_head);
-        self.list_tail = split_node;
-        self.length = at;
-
-        splitted_list
-    }
 }
 
 #[unsafe_destructor]
@@ -830,108 +777,6 @@ mod tests {
         v.iter().map(|x| (*x).clone()).collect()
     }
 
-    #[test]
-    fn test_append() {
-        // Empty to empty
-        {
-            let mut m: DList<int> = DList::new();
-            let mut n = DList::new();
-            m.append(&mut n);
-            check_links(&m);
-            assert_eq!(m.len(), 0);
-            assert_eq!(n.len(), 0);
-        }
-        // Non-empty to empty
-        {
-            let mut m = DList::new();
-            let mut n = DList::new();
-            n.push_back(2i);
-            m.append(&mut n);
-            check_links(&m);
-            assert_eq!(m.len(), 1);
-            assert_eq!(m.pop_back(), Some(2));
-            assert_eq!(n.len(), 0);
-            check_links(&m);
-        }
-        // Empty to non-empty
-        {
-            let mut m = DList::new();
-            let mut n = DList::new();
-            m.push_back(2i);
-            m.append(&mut n);
-            check_links(&m);
-            assert_eq!(m.len(), 1);
-            assert_eq!(m.pop_back(), Some(2));
-            check_links(&m);
-        }
-
-        // Non-empty to non-empty
-        let v = vec![1i,2,3,4,5];
-        let u = vec![9i,8,1,2,3,4,5];
-        let mut m = list_from(v.as_slice());
-        let mut n = list_from(u.as_slice());
-        m.append(&mut n);
-        check_links(&m);
-        let mut sum = v;
-        sum.push_all(u.as_slice());
-        assert_eq!(sum.len(), m.len());
-        for elt in sum.into_iter() {
-            assert_eq!(m.pop_front(), Some(elt))
-        }
-        assert_eq!(n.len(), 0);
-        // let's make sure it's working properly, since we
-        // did some direct changes to private members
-        n.push_back(3);
-        assert_eq!(n.len(), 1);
-        assert_eq!(n.pop_front(), Some(3));
-        check_links(&n);
-    }
-
-    #[test]
-    fn test_split_off() {
-        // singleton
-        {
-            let mut m = DList::new();
-            m.push_back(1i);
-
-            let p = m.split_off(0);
-            assert_eq!(m.len(), 0);
-            assert_eq!(p.len(), 1);
-            assert_eq!(p.back(), Some(&1));
-            assert_eq!(p.front(), Some(&1));
-        }
-
-        // not singleton, forwards
-        {
-            let u = vec![1i,2,3,4,5];
-            let mut m = list_from(u.as_slice());
-            let mut n = m.split_off(2);
-            assert_eq!(m.len(), 2);
-            assert_eq!(n.len(), 3);
-            for elt in range(1i, 3) {
-                assert_eq!(m.pop_front(), Some(elt));
-            }
-            for elt in range(3i, 6) {
-                assert_eq!(n.pop_front(), Some(elt));
-            }
-        }
-        // not singleton, backwards
-        {
-            let u = vec![1i,2,3,4,5];
-            let mut m = list_from(u.as_slice());
-            let mut n = m.split_off(4);
-            assert_eq!(m.len(), 4);
-            assert_eq!(n.len(), 1);
-            for elt in range(1i, 5) {
-                assert_eq!(m.pop_front(), Some(elt));
-            }
-            for elt in range(5i, 6) {
-                assert_eq!(n.pop_front(), Some(elt));
-            }
-        }
-
-    }
-
     #[test]
     fn test_iterator() {
         let m = generate_test();
@@ -1220,6 +1065,41 @@ mod tests {
         assert_eq!(i, v.len());
     }
 
+    #[allow(deprecated)]
+    #[test]
+    fn test_append() {
+        {
+            let mut m = DList::new();
+            let mut n = DList::new();
+            n.push_back(2i);
+            m.append(n);
+            assert_eq!(m.len(), 1);
+            assert_eq!(m.pop_back(), Some(2));
+            check_links(&m);
+        }
+        {
+            let mut m = DList::new();
+            let n = DList::new();
+            m.push_back(2i);
+            m.append(n);
+            assert_eq!(m.len(), 1);
+            assert_eq!(m.pop_back(), Some(2));
+            check_links(&m);
+        }
+
+        let v = vec![1i,2,3,4,5];
+        let u = vec![9i,8,1,2,3,4,5];
+        let mut m = list_from(v.as_slice());
+        m.append(list_from(u.as_slice()));
+        check_links(&m);
+        let mut sum = v;
+        sum.push_all(u.as_slice());
+        assert_eq!(sum.len(), m.len());
+        for elt in sum.into_iter() {
+            assert_eq!(m.pop_front(), Some(elt))
+        }
+    }
+
     #[bench]
     fn bench_collect_into(b: &mut test::Bencher) {
         let v = &[0i; 64];

branches/snap-stage3/src/librustc_back/target/apple_ios_base.rs

@@ -14,7 +14,6 @@ use target::TargetOptions;
 use self::Arch::*;
 
 #[allow(non_camel_case_types)]
-#[derive(Copy)]
 pub enum Arch {
     Armv7,
     Armv7s,
@@ -71,16 +70,8 @@ fn pre_link_args(arch: Arch) -> Vec<String> {
          "-Wl,-syslibroot".to_string(), get_sdk_root(sdk_name)]
 }
 
-fn target_cpu(arch: Arch) -> String {
-    match arch {
-        X86_64 => "x86-64",
-        _ => "generic",
-    }.to_string()
-}
-
 pub fn opts(arch: Arch) -> TargetOptions {
     TargetOptions {
-        cpu: target_cpu(arch),
         dynamic_linking: false,
         executables: true,
         // Although there is an experimental implementation of LLVM which

branches/snap-stage3/src/librustc_back/target/x86_64_apple_darwin.rs

@@ -12,7 +12,6 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::apple_base::opts();
-    base.cpu = "x86-64".to_string();
     base.eliminate_frame_pointer = false;
     base.pre_link_args.push("-m64".to_string());
 

branches/snap-stage3/src/librustc_back/target/x86_64_pc_windows_gnu.rs

@@ -12,7 +12,6 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::windows_base::opts();
-    base.cpu = "x86-64".to_string();
     // On Win64 unwinding is handled by the OS, so we can link libgcc statically.
     base.pre_link_args.push("-static-libgcc".to_string());
     base.pre_link_args.push("-m64".to_string());

branches/snap-stage3/src/librustc_back/target/x86_64_unknown_dragonfly.rs

@@ -12,7 +12,6 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::dragonfly_base::opts();
-    base.cpu = "x86-64".to_string();
     base.pre_link_args.push("-m64".to_string());
 
     Target {

branches/snap-stage3/src/librustc_back/target/x86_64_unknown_freebsd.rs

@@ -12,7 +12,6 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::freebsd_base::opts();
-    base.cpu = "x86-64".to_string();
     base.pre_link_args.push("-m64".to_string());
 
     Target {

branches/snap-stage3/src/librustc_back/target/x86_64_unknown_linux_gnu.rs

@@ -12,7 +12,6 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::linux_base::opts();
-    base.cpu = "x86-64".to_string();
     base.pre_link_args.push("-m64".to_string());
 
     Target {

branches/snap-stage3/src/librustc_typeck/check/closure.rs

@@ -33,7 +33,7 @@ pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
            expr.repr(fcx.tcx()),
            expected.repr(fcx.tcx()));
 
-    let expected_sig_and_kind = expected.map_to_option(fcx, |ty| {
+    let expected_sig_and_kind = expected.to_option(fcx).and_then(|ty| {
         deduce_unboxed_closure_expectations_from_expected_type(fcx, ty)
     });