---

yaml
---
r: 275173
b: refs/heads/stable
c: 9d3bce3
h: refs/heads/master
i:
  275171: 618ef65

Author: mitaa

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 27990edb5296ff2b27e2ff9253a66ee266a0ce72
+refs/heads/stable: 9d3bce38b4e7c2fe706d8228d720222ec2781e30
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/doc/reference.md

@@ -3564,9 +3564,8 @@ Each instance of a trait object includes:
    each method of `SomeTrait` that `T` implements, a pointer to `T`'s
    implementation (i.e. a function pointer).
 
-The purpose of trait objects is to permit "late binding" of methods. Calling a
-method on a trait object results in virtual dispatch at runtime: that is, a
-function pointer is loaded from the trait object vtable and invoked indirectly.
+The purpose of trait objects is to permit "late binding" of methods. A call to
+a method on a trait object is only resolved to a vtable entry at compile time.
 The actual implementation for each vtable entry can vary on an object-by-object
 basis.
 

branches/stable/src/etc/licenseck.py

@@ -9,7 +9,6 @@
 # except according to those terms.
 
 import re
-import os
 
 license_re = re.compile(
 u"""(#|//) Copyright .* The Rust Project Developers. See the COPYRIGHT
@@ -41,9 +40,8 @@
 ]
 
 def check_license(name, contents):
-    name = os.path.normpath(name)
     # Whitelist check
-    if any(name.endswith(os.path.normpath(e)) for e in exceptions):
+    if any(name.endswith(e) for e in exceptions):
         return True
 
     # Xfail check

branches/stable/src/etc/tidy.py

@@ -122,8 +122,7 @@ def interesting_file(f):
             'src/liblibc',
         }
 
-        dirpath = os.path.normpath(dirpath)
-        if any(os.path.normpath(d) in dirpath for d in skippable_dirs):
+        if any(d in dirpath for d in skippable_dirs):
             continue
 
         file_names = [os.path.join(dirpath, f) for f in filenames

branches/stable/src/libcollections/borrow.rs

@@ -95,12 +95,12 @@ pub enum Cow<'a, B: ?Sized + 'a>
 {
     /// Borrowed data.
     #[stable(feature = "rust1", since = "1.0.0")]
-    Borrowed(#[stable(feature = "rust1", since = "1.0.0")] &'a B),
+    Borrowed(#[cfg_attr(not(stage0), stable(feature = "rust1", since = "1.0.0"))] &'a B),
 
     /// Owned data.
     #[stable(feature = "rust1", since = "1.0.0")]
     Owned(
-        #[stable(feature = "rust1", since = "1.0.0")] <B as ToOwned>::Owned
+        #[cfg_attr(not(stage0), stable(feature = "rust1", since = "1.0.0"))] <B as ToOwned>::Owned
     ),
 }
 

branches/stable/src/libcollections/btree/map.rs

@@ -238,13 +238,13 @@ pub enum Entry<'a, K: 'a, V: 'a> {
     /// A vacant Entry
     #[stable(feature = "rust1", since = "1.0.0")]
     Vacant(
-        #[stable(feature = "rust1", since = "1.0.0")] VacantEntry<'a, K, V>
+        #[cfg_attr(not(stage0), stable(feature = "rust1", since = "1.0.0"))] VacantEntry<'a, K, V>
     ),
 
     /// An occupied Entry
     #[stable(feature = "rust1", since = "1.0.0")]
     Occupied(
-        #[stable(feature = "rust1", since = "1.0.0")] OccupiedEntry<'a, K, V>
+        #[cfg_attr(not(stage0), stable(feature = "rust1", since = "1.0.0"))] OccupiedEntry<'a, K, V>
     ),
 }
 

branches/stable/src/libcollections/slice.rs

@@ -407,7 +407,7 @@ impl<T> [T] {
     }
 
     /// Returns an iterator over `size` elements of the slice at a
-    /// time. The chunks are slices and do not overlap. If `size` does not divide the
+    /// time. The chunks do not overlap. If `size` does not divide the
     /// length of the slice, then the last chunk will not have length
     /// `size`.
     ///
@@ -433,7 +433,7 @@ impl<T> [T] {
     }
 
     /// Returns an iterator over `chunk_size` elements of the slice at a time.
-    /// The chunks are mutable slices, and do not overlap. If `chunk_size` does
+    /// The chunks are mutable and do not overlap. If `chunk_size` does
     /// not divide the length of the slice, then the last chunk will not
     /// have length `chunk_size`.
     ///

branches/stable/src/libcore/intrinsics.rs

@@ -586,5 +586,8 @@ extern "rust-intrinsic" {
     /// platforms this is a `*mut *mut T` which is filled in by the compiler and
     /// on MSVC it's `*mut [usize; 2]`. For more information see the compiler's
     /// source as well as std's catch implementation.
+    #[cfg(not(stage0))]
     pub fn try(f: fn(*mut u8), data: *mut u8, local_ptr: *mut u8) -> i32;
+    #[cfg(stage0)]
+    pub fn try(f: fn(*mut u8), data: *mut u8) -> *mut u8;
 }

branches/stable/src/libcore/option.rs

@@ -169,7 +169,7 @@ pub enum Option<T> {
     None,
     /// Some value `T`
     #[stable(feature = "rust1", since = "1.0.0")]
-    Some(#[stable(feature = "rust1", since = "1.0.0")] T)
+    Some(#[cfg_attr(not(stage0), stable(feature = "rust1", since = "1.0.0"))] T)
 }
 
 /////////////////////////////////////////////////////////////////////////////

branches/stable/src/libcore/result.rs

@@ -250,11 +250,11 @@ use option::Option::{self, None, Some};
 pub enum Result<T, E> {
     /// Contains the success value
     #[stable(feature = "rust1", since = "1.0.0")]
-    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),
+    Ok(#[cfg_attr(not(stage0), stable(feature = "rust1", since = "1.0.0"))] T),
 
     /// Contains the error value
     #[stable(feature = "rust1", since = "1.0.0")]
-    Err(#[stable(feature = "rust1", since = "1.0.0")] E)
+    Err(#[cfg_attr(not(stage0), stable(feature = "rust1", since = "1.0.0"))] E)
 }
 
 /////////////////////////////////////////////////////////////////////////////

branches/stable/src/liblibc

@@ -1 +1 @@
-Subproject commit 16f1c190afbc7605ed50a40f802189e436de68f6
+Subproject commit 1b1eea2cdd77c63d73ba0b09b905a91910d1c992

branches/stable/src/librustc_data_structures/bitvec.rs

@@ -50,45 +50,6 @@ impl BitVector {
         let extra_words = self.data.len() - num_words;
         self.data.extend((0..extra_words).map(|_| 0));
     }
-
-    /// Iterates over indexes of set bits in a sorted order
-    pub fn iter<'a>(&'a self) -> BitVectorIter<'a> {
-        BitVectorIter {
-            iter: self.data.iter(),
-            current: 0,
-            idx: 0
-        }
-    }
-}
-
-pub struct BitVectorIter<'a> {
-    iter: ::std::slice::Iter<'a, u64>,
-    current: u64,
-    idx: usize
-}
-
-impl<'a> Iterator for BitVectorIter<'a> {
-    type Item = usize;
-    fn next(&mut self) -> Option<usize> {
-        while self.current == 0 {
-            self.current = if let Some(&i) = self.iter.next() {
-                if i == 0 {
-                    self.idx += 64;
-                    continue;
-                } else {
-                    self.idx = u64s(self.idx) * 64;
-                    i
-                }
-            } else {
-                return None;
-            }
-        }
-        let offset = self.current.trailing_zeros() as usize;
-        self.current >>= offset;
-        self.current >>= 1; // shift otherwise overflows for 0b1000_0000_…_0000
-        self.idx += offset + 1;
-        return Some(self.idx - 1);
-    }
 }
 
 /// A "bit matrix" is basically a square matrix of booleans
@@ -192,46 +153,6 @@ fn word_mask(index: usize) -> (usize, u64) {
     (word, mask)
 }
 
-#[test]
-fn bitvec_iter_works() {
-    let mut bitvec = BitVector::new(100);
-    bitvec.insert(1);
-    bitvec.insert(10);
-    bitvec.insert(19);
-    bitvec.insert(62);
-    bitvec.insert(63);
-    bitvec.insert(64);
-    bitvec.insert(65);
-    bitvec.insert(66);
-    bitvec.insert(99);
-    assert_eq!(bitvec.iter().collect::<Vec<_>>(), [1, 10, 19, 62, 63, 64, 65, 66, 99]);
-}
-
-#[test]
-fn bitvec_iter_works_2() {
-    let mut bitvec = BitVector::new(300);
-    bitvec.insert(1);
-    bitvec.insert(10);
-    bitvec.insert(19);
-    bitvec.insert(62);
-    bitvec.insert(66);
-    bitvec.insert(99);
-    bitvec.insert(299);
-    assert_eq!(bitvec.iter().collect::<Vec<_>>(), [1, 10, 19, 62, 66, 99, 299]);
-
-}
-
-#[test]
-fn bitvec_iter_works_3() {
-    let mut bitvec = BitVector::new(319);
-    bitvec.insert(0);
-    bitvec.insert(127);
-    bitvec.insert(191);
-    bitvec.insert(255);
-    bitvec.insert(319);
-    assert_eq!(bitvec.iter().collect::<Vec<_>>(), [0, 127, 191, 255, 319]);
-}
-
 #[test]
 fn union_two_vecs() {
     let mut vec1 = BitVector::new(65);

branches/stable/src/librustc_mir/transform/mod.rs

@@ -13,3 +13,4 @@ pub mod simplify_cfg;
 pub mod erase_regions;
 pub mod no_landing_pads;
 pub mod type_check;
+mod util;

branches/stable/src/librustc_mir/transform/simplify_cfg.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rustc_data_structures::bitvec::BitVector;
 use rustc::middle::const_eval::ConstVal;
 use rustc::middle::infer;
 use rustc::mir::repr::*;
+use transform::util;
 use rustc::mir::transform::MirPass;
 
 pub struct SimplifyCfg;
@@ -22,21 +22,23 @@ impl SimplifyCfg {
     }
 
     fn remove_dead_blocks(&self, mir: &mut Mir) {
-        let mut seen = BitVector::new(mir.basic_blocks.len());
+        let mut seen = vec![false; mir.basic_blocks.len()];
+
         // These blocks are always required.
-        seen.insert(START_BLOCK.index());
-        seen.insert(END_BLOCK.index());
+        seen[START_BLOCK.index()] = true;
+        seen[END_BLOCK.index()] = true;
 
-        let mut worklist = Vec::with_capacity(4);
-        worklist.push(START_BLOCK);
+        let mut worklist = vec![START_BLOCK];
         while let Some(bb) = worklist.pop() {
             for succ in mir.basic_block_data(bb).terminator().successors().iter() {
-                if seen.insert(succ.index()) {
+                if !seen[succ.index()] {
+                    seen[succ.index()] = true;
                     worklist.push(*succ);
                 }
             }
         }
-        retain_basic_blocks(mir, &seen);
+
+        util::retain_basic_blocks(mir, &seen);
     }
 
     fn remove_goto_chains(&self, mir: &mut Mir) -> bool {
@@ -88,12 +90,12 @@ impl SimplifyCfg {
         for bb in mir.all_basic_blocks() {
             let basic_block = mir.basic_block_data_mut(bb);
             let mut terminator = basic_block.terminator_mut();
+
             *terminator = match *terminator {
                 Terminator::If { ref targets, .. } if targets.0 == targets.1 => {
                     changed = true;
                     Terminator::Goto { target: targets.0 }
                 }
-
                 Terminator::If { ref targets, cond: Operand::Constant(Constant {
                     literal: Literal::Value {
                         value: ConstVal::Bool(cond)
@@ -106,7 +108,6 @@ impl SimplifyCfg {
                         Terminator::Goto { target: targets.1 }
                     }
                 }
-
                 Terminator::SwitchInt { ref targets, .. }  if targets.len() == 1 => {
                     Terminator::Goto { target: targets[0] }
                 }
@@ -130,27 +131,3 @@ impl MirPass for SimplifyCfg {
         mir.basic_blocks.shrink_to_fit();
     }
 }
-
-/// Mass removal of basic blocks to keep the ID-remapping cheap.
-fn retain_basic_blocks(mir: &mut Mir, keep: &BitVector) {
-    let num_blocks = mir.basic_blocks.len();
-
-    let mut replacements: Vec<_> = (0..num_blocks).map(BasicBlock::new).collect();
-    let mut used_blocks = 0;
-    for alive_index in keep.iter() {
-        replacements[alive_index] = BasicBlock::new(used_blocks);
-        if alive_index != used_blocks {
-            // Swap the next alive block data with the current available slot. Since alive_index is
-            // non-decreasing this is a valid operation.
-            mir.basic_blocks.swap(alive_index, used_blocks);
-        }
-        used_blocks += 1;
-    }
-    mir.basic_blocks.truncate(used_blocks);
-
-    for bb in mir.all_basic_blocks() {
-        for target in mir.basic_block_data_mut(bb).terminator_mut().successors_mut() {
-            *target = replacements[target.index()];
-        }
-    }
-}

branches/stable/src/librustc_mir/transform/util.rs

@@ -0,0 +1,51 @@
+// Copyright 2015 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.
+
+use rustc::mir::repr::*;
+
+/// Update basic block ids in all terminators using the given replacements,
+/// useful e.g. after removal of several basic blocks to update all terminators
+/// in a single pass
+pub fn update_basic_block_ids(mir: &mut Mir, replacements: &[BasicBlock]) {
+    for bb in mir.all_basic_blocks() {
+        for target in mir.basic_block_data_mut(bb).terminator_mut().successors_mut() {
+            *target = replacements[target.index()];
+        }
+    }
+}
+
+/// Mass removal of basic blocks to keep the ID-remapping cheap.
+pub fn retain_basic_blocks(mir: &mut Mir, keep: &[bool]) {
+    let num_blocks = mir.basic_blocks.len();
+
+    // Check that we have a usage flag for every block
+    assert_eq!(num_blocks, keep.len());
+
+    let first_dead = match keep.iter().position(|&k| !k) {
+        None => return,
+        Some(first_dead) => first_dead,
+    };
+
+    // `replacements` maps the old block ids to the new ones
+    let mut replacements: Vec<_> = (0..num_blocks).map(BasicBlock::new).collect();
+
+    let mut dead = 0;
+    for i in first_dead..num_blocks {
+        if keep[i] {
+            replacements[i] = BasicBlock::new(i - dead);
+            mir.basic_blocks.swap(i, i - dead);
+        } else {
+            dead += 1;
+        }
+    }
+    mir.basic_blocks.truncate(num_blocks - dead);
+
+    update_basic_block_ids(mir, &replacements);
+}