---

yaml
---
r: 132477
b: refs/heads/dist-snap
c: e753dbb
h: refs/heads/master
i:
  132475: 09ab5d5
v: v3

Author: huonw

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 457a3c991d79b971be07fce75f9d0c12848fb37c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 765a23f73db0fc23024849ea1fc0831bda58687d
+refs/heads/dist-snap: e753dbb431534b4b07b2724d7bbbcef59ecbd4d3
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/.gitignore

@@ -64,12 +64,6 @@
 /nd/
 /rt/
 /rustllvm/
-/src/libunicode/DerivedCoreProperties.txt
-/src/libunicode/EastAsianWidth.txt
-/src/libunicode/HangulSyllableType.txt
-/src/libunicode/PropList.txt
-/src/libunicode/Scripts.txt
-/src/libunicode/UnicodeData.txt
 /stage0/
 /stage1/
 /stage2/

branches/dist-snap/src/doc/guide.md

@@ -1060,6 +1060,7 @@ you create a new type that's a synonym for another one:
 
 ```
 struct Inches(int);
+struct Centimeters(int);
 
 let length = Inches(10);
 
@@ -1626,6 +1627,10 @@ Check out the generated `Cargo.toml`:
 name = "guessing_game"
 version = "0.1.0"
 authors = ["Your Name <[email protected]>"]
+
+[[bin]]
+
+name = "guessing_game"
 ```
 
 Cargo gets this information from your environment. If it's not correct, go ahead

branches/dist-snap/src/libcollections/vec.rs

@@ -964,7 +964,7 @@ impl<T> Vec<T> {
     #[inline]
     pub fn swap_remove(&mut self, index: uint) -> Option<T> {
         let length = self.len();
-        if length > 0 && index < length - 1 {
+        if index < length - 1 {
             self.as_mut_slice().swap(index, length - 1);
         } else if index >= length {
             return None
@@ -2003,12 +2003,6 @@ mod tests {
         let _ = vec[3];
     }
 
-    #[test]
-    fn test_swap_remove_empty() {
-        let mut vec: Vec<uint> = vec!();
-        assert_eq!(vec.swap_remove(0), None);
-    }
-
     #[bench]
     fn bench_new(b: &mut Bencher) {
         b.iter(|| {

branches/dist-snap/src/libcore/cmp.rs

@@ -100,40 +100,6 @@ pub enum Ordering {
    Greater = 1i,
 }
 
-impl Ordering {
-    /// Reverse the `Ordering`, so that `Less` becomes `Greater` and
-    /// vice versa.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// assert_eq!(Less.reverse(), Greater);
-    /// assert_eq!(Equal.reverse(), Equal);
-    /// assert_eq!(Greater.reverse(), Less);
-    ///
-    ///
-    /// let mut data = &mut [2u, 10, 5, 8];
-    ///
-    /// // sort the array from largest to smallest.
-    /// data.sort_by(|a, b| a.cmp(b).reverse());
-    ///
-    /// assert_eq!(data, &mut [10u, 8, 5, 2]);
-    /// ```
-    #[inline]
-    #[experimental]
-    pub fn reverse(self) -> Ordering {
-        unsafe {
-            // this compiles really nicely (to a single instruction);
-            // an explicit match has a pile of branches and
-            // comparisons.
-            //
-            // NB. it is safe because of the explicit discriminants
-            // given above.
-            ::mem::transmute::<_, Ordering>(-(self as i8))
-        }
-    }
-}
-
 /// Trait for types that form a [total order](
 /// https://en.wikipedia.org/wiki/Total_order).
 ///

branches/dist-snap/src/libcore/num/mod.rs

@@ -279,8 +279,8 @@ pub fn abs<T: Signed>(value: T) -> T {
 
 /// The positive difference of two numbers.
 ///
-/// Returns zero if `x` is less than or equal to `y`, otherwise the difference
-/// between `x` and `y` is returned.
+/// Returns `zero` if the number is less than or equal to `other`,
+/// otherwise the difference between `self` and `other` is returned.
 #[inline(always)]
 pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
     x.abs_sub(&y)

branches/dist-snap/src/libcoretest/cmp.rs

@@ -28,13 +28,6 @@ fn test_mut_int_totalord() {
     assert_eq!((&mut 12i).cmp(&&mut -5), Greater);
 }
 
-#[test]
-fn test_ordering_reverse() {
-    assert_eq!(Less.reverse(), Greater);
-    assert_eq!(Equal.reverse(), Equal);
-    assert_eq!(Greater.reverse(), Less);
-}
-
 #[test]
 fn test_ordering_order() {
     assert!(Less < Equal);

branches/dist-snap/src/librustc/back/link.rs

@@ -32,7 +32,6 @@ use std::char;
 use std::collections::HashSet;
 use std::io::{fs, TempDir, Command};
 use std::io;
-use std::mem;
 use std::ptr;
 use std::str;
 use std::string::String;
@@ -46,36 +45,6 @@ use syntax::attr::AttrMetaMethods;
 use syntax::codemap::Span;
 use syntax::parse::token;
 
-// RLIB LLVM-BYTECODE OBJECT LAYOUT
-// Version 1
-// Bytes    Data
-// 0..10    "RUST_OBJECT" encoded in ASCII
-// 11..14   format version as little-endian u32
-// 15..22   size in bytes of deflate compressed LLVM bitcode as
-//          little-endian u64
-// 23..     compressed LLVM bitcode
-
-// This is the "magic number" expected at the beginning of a LLVM bytecode
-// object in an rlib.
-pub static RLIB_BYTECODE_OBJECT_MAGIC: &'static [u8] = b"RUST_OBJECT";
-
-// The version number this compiler will write to bytecode objects in rlibs
-pub static RLIB_BYTECODE_OBJECT_VERSION: u32 = 1;
-
-// The offset in bytes the bytecode object format version number can be found at
-pub static RLIB_BYTECODE_OBJECT_VERSION_OFFSET: uint = 11;
-
-// The offset in bytes the size of the compressed bytecode can be found at in
-// format version 1
-pub static RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET: uint =
-    RLIB_BYTECODE_OBJECT_VERSION_OFFSET + 4;
-
-// The offset in bytes the compressed LLVM bytecode can be found at in format
-// version 1
-pub static RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET: uint =
-    RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET + 8;
-
-
 #[deriving(Clone, PartialEq, PartialOrd, Ord, Eq)]
 pub enum OutputType {
     OutputTypeBitcode,
@@ -1134,44 +1103,28 @@ fn link_rlib<'a>(sess: &'a Session,
             // is never exactly 16 bytes long by adding a 16 byte extension to
             // it. This is to work around a bug in LLDB that would cause it to
             // crash if the name of a file in an archive was exactly 16 bytes.
-            let bc_filename = obj_filename.with_extension("bc");
-            let bc_deflated_filename = obj_filename.with_extension("bytecode.deflate");
-
-            let bc_data = match fs::File::open(&bc_filename).read_to_end() {
-                Ok(buffer) => buffer,
-                Err(e) => sess.fatal(format!("failed to read bytecode: {}",
-                                             e).as_slice())
-            };
-
-            let bc_data_deflated = match flate::deflate_bytes(bc_data.as_slice()) {
-                Some(compressed) => compressed,
-                None => sess.fatal(format!("failed to compress bytecode from {}",
-                                           bc_filename.display()).as_slice())
-            };
-
-            let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) {
-                Ok(file) => file,
-                Err(e) => {
-                    sess.fatal(format!("failed to create compressed bytecode \
-                                        file: {}", e).as_slice())
-                }
-            };
-
-            match write_rlib_bytecode_object_v1(&mut bc_file_deflated,
-                                                bc_data_deflated.as_slice()) {
+            let bc = obj_filename.with_extension("bc");
+            let bc_deflated = obj_filename.with_extension("bytecode.deflate");
+            match fs::File::open(&bc).read_to_end().and_then(|data| {
+                fs::File::create(&bc_deflated)
+                    .write(match flate::deflate_bytes(data.as_slice()) {
+                        Some(compressed) => compressed,
+                        None => sess.fatal("failed to compress bytecode")
+                     }.as_slice())
+            }) {
                 Ok(()) => {}
                 Err(e) => {
                     sess.err(format!("failed to write compressed bytecode: \
-                                      {}", e).as_slice());
+                                      {}",
+                                     e).as_slice());
                     sess.abort_if_errors()
                 }
-            };
-
-            ab.add_file(&bc_deflated_filename).unwrap();
-            remove(sess, &bc_deflated_filename);
+            }
+            ab.add_file(&bc_deflated).unwrap();
+            remove(sess, &bc_deflated);
             if !sess.opts.cg.save_temps &&
                !sess.opts.output_types.contains(&OutputTypeBitcode) {
-                remove(sess, &bc_filename);
+                remove(sess, &bc);
             }
         }
 
@@ -1181,32 +1134,6 @@ fn link_rlib<'a>(sess: &'a Session,
     ab
 }
 
-fn write_rlib_bytecode_object_v1<T: Writer>(writer: &mut T,
-                                            bc_data_deflated: &[u8])
-                                         -> ::std::io::IoResult<()> {
-    let bc_data_deflated_size: u64 = bc_data_deflated.as_slice().len() as u64;
-
-    try! { writer.write(RLIB_BYTECODE_OBJECT_MAGIC) };
-    try! { writer.write_le_u32(1) };
-    try! { writer.write_le_u64(bc_data_deflated_size) };
-    try! { writer.write(bc_data_deflated.as_slice()) };
-
-    let number_of_bytes_written_so_far =
-        RLIB_BYTECODE_OBJECT_MAGIC.len() +                // magic id
-        mem::size_of_val(&RLIB_BYTECODE_OBJECT_VERSION) + // version
-        mem::size_of_val(&bc_data_deflated_size) +        // data size field
-        bc_data_deflated_size as uint;                    // actual data
-
-    // If the number of bytes written to the object so far is odd, add a
-    // padding byte to make it even. This works around a crash bug in LLDB
-    // (see issue #15950)
-    if number_of_bytes_written_so_far % 2 == 1 {
-        try! { writer.write_u8(0) };
-    }
-
-    return Ok(());
-}
-
 // Create a static archive
 //
 // This is essentially the same thing as an rlib, but it also involves adding

branches/dist-snap/src/librustc/back/lto.rs

@@ -20,8 +20,6 @@ use util::common::time;
 use libc;
 use flate;
 
-use std::mem;
-
 pub fn run(sess: &session::Session, llmod: ModuleRef,
            tm: TargetMachineRef, reachable: &[String]) {
     if sess.opts.cg.prefer_dynamic {
@@ -59,66 +57,36 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
         let file = path.filename_str().unwrap();
         let file = file.slice(3, file.len() - 5); // chop off lib/.rlib
         debug!("reading {}", file);
-        let bc_encoded = time(sess.time_passes(),
-                              format!("read {}.bytecode.deflate", name).as_slice(),
-                              (),
-                              |_| {
-                                  archive.read(format!("{}.bytecode.deflate",
-                                                       file).as_slice())
-                              });
-        let bc_encoded = bc_encoded.expect("missing compressed bytecode in archive!");
-        let bc_extractor = if is_versioned_bytecode_format(bc_encoded) {
-            |_| {
-                // Read the version
-                let version = extract_bytecode_format_version(bc_encoded);
-
-                if version == 1 {
-                    // The only version existing so far
-                    let data_size = extract_compressed_bytecode_size_v1(bc_encoded);
-                    let compressed_data = bc_encoded.slice(
-                        link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET,
-                        link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint);
-
-                    match flate::inflate_bytes(compressed_data) {
-                        Some(inflated) => inflated,
-                        None => {
-                            sess.fatal(format!("failed to decompress bc of `{}`",
-                                               name).as_slice())
-                        }
-                    }
-                } else {
-                    sess.fatal(format!("Unsupported bytecode format version {}",
-                                       version).as_slice())
-                }
-            }
-        } else {
-            // the object must be in the old, pre-versioning format, so simply
-            // inflate everything and let LLVM decide if it can make sense of it
-            |_| {
-                match flate::inflate_bytes(bc_encoded) {
-                    Some(bc) => bc,
-                    None => {
-                        sess.fatal(format!("failed to decompress bc of `{}`",
-                                           name).as_slice())
-                    }
-                }
-            }
-        };
-
-        let bc_decoded = time(sess.time_passes(),
-                              format!("decode {}.bc", file).as_slice(),
-                              (),
-                              bc_extractor);
-
-        let ptr = bc_decoded.as_slice().as_ptr();
+        let bc = time(sess.time_passes(),
+                      format!("read {}.bytecode.deflate", name).as_slice(),
+                      (),
+                      |_| {
+                          archive.read(format!("{}.bytecode.deflate",
+                                               file).as_slice())
+                      });
+        let bc = bc.expect("missing compressed bytecode in archive!");
+        let bc = time(sess.time_passes(),
+                      format!("inflate {}.bc", file).as_slice(),
+                      (),
+                      |_| {
+                          match flate::inflate_bytes(bc) {
+                              Some(bc) => bc,
+                              None => {
+                                  sess.fatal(format!("failed to decompress \
+                                                      bc of `{}`",
+                                                     name).as_slice())
+                              }
+                          }
+                      });
+        let ptr = bc.as_slice().as_ptr();
         debug!("linking {}", name);
         time(sess.time_passes(),
              format!("ll link {}", name).as_slice(),
              (),
              |()| unsafe {
             if !llvm::LLVMRustLinkInExternalBitcode(llmod,
                                                     ptr as *const libc::c_char,
-                                                    bc_decoded.len() as libc::size_t) {
+                                                    bc.len() as libc::size_t) {
                 link::llvm_err(sess,
                                format!("failed to load bc of `{}`",
                                        name.as_slice()));
@@ -169,28 +137,3 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
     }
     debug!("lto done");
 }
-
-fn is_versioned_bytecode_format(bc: &[u8]) -> bool {
-    let magic_id_byte_count = link::RLIB_BYTECODE_OBJECT_MAGIC.len();
-    return bc.len() > magic_id_byte_count &&
-           bc.slice(0, magic_id_byte_count) == link::RLIB_BYTECODE_OBJECT_MAGIC;
-}
-
-fn extract_bytecode_format_version(bc: &[u8]) -> u32 {
-    return read_from_le_bytes::<u32>(bc, link::RLIB_BYTECODE_OBJECT_VERSION_OFFSET);
-}
-
-fn extract_compressed_bytecode_size_v1(bc: &[u8]) -> u64 {
-    return read_from_le_bytes::<u64>(bc, link::RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET);
-}
-
-fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: uint) -> T {
-    let byte_data = bytes.slice(position_in_bytes,
-                                position_in_bytes + mem::size_of::<T>());
-    let data = unsafe {
-        *(byte_data.as_ptr() as *const T)
-    };
-
-    Int::from_le(data)
-}
-