---

yaml
---
r: 149819
b: refs/heads/try2
c: 3bf724e
h: refs/heads/master
i:
  149817: 4a1e096
  149815: 4c32a45
v: v3

Author: Robert Gawdzik

[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: 5f64adc44b1245ba644f66c29d6bbc5c940422c9
+refs/heads/try2: 3bf724e44bd691871e700d90e0665743112577d5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -745,8 +745,8 @@ Version 0.2  (March 2012)
       * Merged per-platform std::{os*, fs*} to core::{libc, os}
       * Extensive cleanup, regularization in libstd, libcore
 
-Version 0.1  (January 20, 2012)
--------------------------------
+Version 0.1  (January 2012)
+---------------------------
 
    * Most language features work, including:
       * Unique pointers, unique closures, move semantics

branches/try2/src/libcollections/btree.rs

@@ -92,11 +92,6 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BTree<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Eq for BTree<K, V> {
-    fn eq(&self, other: &BTree<K, V>) -> bool {
-        self.equals(other)
-    }
-}
 
 impl<K: TotalOrd, V: TotalEq> TotalEq for BTree<K, V> {
     ///Testing equality on BTrees by comparing the root.
@@ -105,12 +100,6 @@ impl<K: TotalOrd, V: TotalEq> TotalEq for BTree<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Ord for BTree<K, V> {
-    fn lt(&self, other: &BTree<K, V>) -> bool {
-        self.cmp(other) == Less
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalOrd for BTree<K, V> {
     ///Returns an ordering based on the root nodes of each BTree.
     fn cmp(&self, other: &BTree<K, V>) -> Ordering {
@@ -202,12 +191,6 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Node<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Eq for Node<K, V> {
-    fn eq(&self, other: &Node<K, V>) -> bool {
-        self.equals(other)
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalEq for Node<K, V> {
     ///Returns whether two nodes are equal based on the keys of each element.
     ///Two nodes are equal if all of their keys are the same.
@@ -232,12 +215,6 @@ impl<K: TotalOrd, V: TotalEq> TotalEq for Node<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Ord for Node<K, V> {
-    fn lt(&self, other: &Node<K, V>) -> bool {
-        self.cmp(other) == Less
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalOrd for Node<K, V> {
     ///Implementation of TotalOrd for Nodes.
     fn cmp(&self, other: &Node<K, V>) -> Ordering {
@@ -403,25 +380,13 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Leaf<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Eq for Leaf<K, V> {
-    fn eq(&self, other: &Leaf<K, V>) -> bool {
-        self.equals(other)
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalEq for Leaf<K, V> {
     ///Implementation of equals function for leaves that compares LeafElts.
     fn equals(&self, other: &Leaf<K, V>) -> bool {
         self.elts.equals(&other.elts)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Ord for Leaf<K, V> {
-    fn lt(&self, other: &Leaf<K, V>) -> bool {
-        self.cmp(other) == Less
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalOrd for Leaf<K, V> {
     ///Returns an ordering based on the first element of each Leaf.
     fn cmp(&self, other: &Leaf<K, V>) -> Ordering {
@@ -637,25 +602,13 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Branch<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Eq for Branch<K, V> {
-    fn eq(&self, other: &Branch<K, V>) -> bool {
-        self.equals(other)
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalEq for Branch<K, V> {
     ///Equals function for Branches--compares all the elements in each branch
     fn equals(&self, other: &Branch<K, V>) -> bool {
         self.elts.equals(&other.elts)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Ord for Branch<K, V> {
-    fn lt(&self, other: &Branch<K, V>) -> bool {
-        self.cmp(other) == Less
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalOrd for Branch<K, V> {
     ///Compares the first elements of two branches to determine an ordering
     fn cmp(&self, other: &Branch<K, V>) -> Ordering {
@@ -710,25 +663,13 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for LeafElt<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Eq for LeafElt<K, V> {
-    fn eq(&self, other: &LeafElt<K, V>) -> bool {
-        self.equals(other)
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalEq for LeafElt<K, V> {
     ///TotalEq for LeafElts
     fn equals(&self, other: &LeafElt<K, V>) -> bool {
         self.key.equals(&other.key) && self.value.equals(&other.value)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Ord for LeafElt<K, V> {
-    fn lt(&self, other: &LeafElt<K, V>) -> bool {
-        self.cmp(other) == Less
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalOrd for LeafElt<K, V> {
     ///Returns an ordering based on the keys of the LeafElts.
     fn cmp(&self, other: &LeafElt<K, V>) -> Ordering {
@@ -764,25 +705,13 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BranchElt<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Eq for BranchElt<K, V>{
-    fn eq(&self, other: &BranchElt<K, V>) -> bool {
-        self.equals(other)
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalEq for BranchElt<K, V>{
     ///TotalEq for BranchElts
     fn equals(&self, other: &BranchElt<K, V>) -> bool {
         self.key.equals(&other.key)&&self.value.equals(&other.value)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> Ord for BranchElt<K, V> {
-    fn lt(&self, other: &BranchElt<K, V>) -> bool {
-        self.cmp(other) == Less
-    }
-}
-
 impl<K: TotalOrd, V: TotalEq> TotalOrd for BranchElt<K, V> {
     ///Fulfills TotalOrd for BranchElts
     fn cmp(&self, other: &BranchElt<K, V>) -> Ordering {

branches/try2/src/libcollections/dlist.rs

@@ -607,7 +607,7 @@ impl<A: Eq> Eq for DList<A> {
     }
 }
 
-impl<A: Ord> Ord for DList<A> {
+impl<A: Eq + Ord> Ord for DList<A> {
     fn lt(&self, other: &DList<A>) -> bool {
         iter::order::lt(self.iter(), other.iter())
     }

branches/try2/src/libextra/workcache.rs

@@ -88,7 +88,7 @@ use std::io::{File, MemWriter};
 *
 */
 
-#[deriving(Clone, Eq, Encodable, Decodable, Ord, TotalOrd, TotalEq)]
+#[deriving(Clone, Eq, Encodable, Decodable, TotalOrd, TotalEq)]
 struct WorkKey {
     kind: ~str,
     name: ~str

branches/try2/src/librustc/back/archive.rs

@@ -16,7 +16,6 @@ use metadata::filesearch;
 use lib::llvm::{ArchiveRef, llvm};
 
 use std::cast;
-use std::vec_ng::Vec;
 use std::io::fs;
 use std::io;
 use std::libc;
@@ -42,7 +41,7 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,
         paths: &[&Path]) -> ProcessOutput {
     let ar = get_ar_prog(sess);
 
-    let mut args = vec!(args.to_owned());
+    let mut args = ~[args.to_owned()];
     let mut paths = paths.iter().map(|p| p.as_str().unwrap().to_owned());
     args.extend(&mut paths);
     debug!("{} {}", ar, args.connect(" "));
@@ -90,25 +89,17 @@ impl Archive {
     }
 
     /// Read a file in the archive
-    pub fn read(&self, file: &str) -> Vec<u8> {
+    pub fn read(&self, file: &str) -> ~[u8] {
         // Apparently if "ar p" is used on windows, it generates a corrupt file
         // which has bad headers and LLVM will immediately choke on it
         if cfg!(windows) && cfg!(windows) { // FIXME(#10734) double-and
             let loc = TempDir::new("rsar").unwrap();
             let archive = os::make_absolute(&self.dst);
             run_ar(self.sess, "x", Some(loc.path()), [&archive,
                                                       &Path::new(file)]);
-            let result: Vec<u8> =
-                fs::File::open(&loc.path().join(file)).read_to_end()
-                                                      .unwrap()
-                                                      .move_iter()
-                                                      .collect();
-            result
+            fs::File::open(&loc.path().join(file)).read_to_end().unwrap()
         } else {
-            run_ar(self.sess,
-                   "p",
-                   None,
-                   [&self.dst, &Path::new(file)]).output.move_iter().collect()
+            run_ar(self.sess, "p", None, [&self.dst, &Path::new(file)]).output
         }
     }
 
@@ -128,11 +119,11 @@ impl Archive {
                     lto: bool) -> io::IoResult<()> {
         let object = format!("{}.o", name);
         let bytecode = format!("{}.bc", name);
-        let mut ignore = vec!(METADATA_FILENAME, bytecode.as_slice());
+        let mut ignore = ~[METADATA_FILENAME, bytecode.as_slice()];
         if lto {
             ignore.push(object.as_slice());
         }
-        self.add_archive(rlib, name, ignore.as_slice())
+        self.add_archive(rlib, name, ignore)
     }
 
     /// Adds an arbitrary file to this archive
@@ -152,7 +143,7 @@ impl Archive {
     }
 
     /// Lists all files in an archive
-    pub fn files(&self) -> Vec<~str> {
+    pub fn files(&self) -> ~[~str] {
         let output = run_ar(self.sess, "t", None, [&self.dst]);
         let output = str::from_utf8(output.output).unwrap();
         // use lines_any because windows delimits output with `\r\n` instead of
@@ -177,7 +168,7 @@ impl Archive {
         // all SYMDEF files as these are just magical placeholders which get
         // re-created when we make a new archive anyway.
         let files = try!(fs::readdir(loc.path()));
-        let mut inputs = Vec::new();
+        let mut inputs = ~[];
         for file in files.iter() {
             let filename = file.filename_str().unwrap();
             if skip.iter().any(|s| *s == filename) { continue }
@@ -191,7 +182,7 @@ impl Archive {
         if inputs.len() == 0 { return Ok(()) }
 
         // Finally, add all the renamed files to this archive
-        let mut args = vec!(&self.dst);
+        let mut args = ~[&self.dst];
         args.extend(&mut inputs.iter());
         run_ar(self.sess, "r", None, args.as_slice());
         Ok(())

branches/try2/src/librustc/back/arm.rs

@@ -15,9 +15,9 @@ use syntax::abi;
 
 pub fn get_target_strs(target_triple: ~str, target_os: abi::Os) -> target_strs::t {
     let cc_args = if target_triple.contains("thumb") {
-        vec!(~"-mthumb")
+        ~[~"-mthumb"]
     } else {
-        vec!(~"-marm")
+        ~[~"-marm"]
     };
     return target_strs::t {
         module_asm: ~"",