---

yaml
---
r: 159159
b: refs/heads/snap-stage3
c: c46b5b5
h: refs/heads/master
i:
  159157: df1eda2
  159155: da0ddfd
  159151: 90bbb60
v: v3

Author: Jakub Bukaj

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 40fb87d40f681f5356af42175fc7b85da387f037
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 7eae5b458993b8a030ed9bb6e65c12babc4bbe4b
+refs/heads/snap-stage3: c46b5b5314377fcbac3ba8facfcad98f4bc8aae6
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/doc/guide-pointers.md

@@ -133,11 +133,11 @@ pass-by-reference. Basically, languages can make two choices (this is made
 up syntax, it's not Rust):
 
 ```{notrust,ignore}
-fn foo(x) {
+func foo(x) {
     x = 5
 }
 
-fn main() {
+func main() {
     i = 1
     foo(i)
     // what is the value of i here?
@@ -153,11 +153,11 @@ So what do pointers have to do with this? Well, since pointers point to a
 location in memory...
 
 ```{notrust,ignore}
-fn foo(&int x) {
+func foo(&int x) {
     *x = 5
 }
 
-fn main() {
+func main() {
     i = 1
     foo(&i)
     // what is the value of i here?
@@ -192,13 +192,13 @@ When you combine pointers and functions, it's easy to accidentally invalidate
 the memory the pointer is pointing to. For example:
 
 ```{notrust,ignore}
-fn make_pointer(): &int {
+func make_pointer(): &int {
     x = 5;
 
     return &x;
 }
 
-fn main() {
+func main() {
     &int i = make_pointer();
     *i = 5; // uh oh!
 }
@@ -214,11 +214,11 @@ issue. Two pointers are said to alias when they point at the same location
 in memory. Like this:
 
 ```{notrust,ignore}
-fn mutate(&int i, int j) {
+func mutate(&int i, int j) {
     *i = j;
 }
 
-fn main() {
+func main() {
   x = 5;
   y = &x;
   z = &x; //y and z are aliased

branches/snap-stage3/src/doc/po4a.conf

@@ -19,7 +19,7 @@
 [type: text] src/doc/guide-tasks.md $lang:doc/l10n/$lang/guide-tasks.md
 [type: text] src/doc/guide-testing.md $lang:doc/l10n/$lang/guide-testing.md
 [type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-unsafe.md
-[type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-crates.md
+[type: text] src/doc/guide-crates.md $lang:doc/l10n/$lang/guide-crates.md
 [type: text] src/doc/guide.md $lang:doc/l10n/$lang/guide.md
 [type: text] src/doc/index.md $lang:doc/l10n/$lang/index.md
 [type: text] src/doc/intro.md $lang:doc/l10n/$lang/intro.md

branches/snap-stage3/src/doc/reference.md

@@ -2653,9 +2653,10 @@ An expression may have two roles: it always produces a *value*, and it may have
 value, and has effects during *evaluation*. Many expressions contain
 sub-expressions (operands). The meaning of each kind of expression dictates
 several things:
-  * Whether or not to evaluate the sub-expressions when evaluating the
-  * expression The order in which to evaluate the sub-expressions How to
-  * combine the sub-expressions' values to obtain the value of the expression.
+
+* Whether or not to evaluate the sub-expressions when evaluating the expression
+* The order in which to evaluate the sub-expressions
+* How to combine the sub-expressions' values to obtain the value of the expression
 
 In this way, the structure of expressions dictates the structure of execution.
 Blocks are just another kind of expression, so blocks, statements, expressions,

branches/snap-stage3/src/etc/snapshot.py

@@ -75,7 +75,11 @@ def full_snapshot_name(date, rev, platform, hsh):
 
 
 def get_kernel(triple):
-    os_name = triple.split('-')[2]
+    t = triple.split('-')
+    if len(t) == 2:
+      os_name = t[1]
+    else:
+      os_name = t[2]
     if os_name == "windows":
         return "winnt"
     if os_name == "darwin":

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

@@ -258,9 +258,9 @@ impl Bitv {
 
     /// Retrieves the value at index `i`.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `i` is out of bounds.
+    /// Panics if `i` is out of bounds.
     ///
     /// # Example
     ///
@@ -285,9 +285,9 @@ impl Bitv {
 
     /// Sets the value of a bit at a index `i`.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `i` is out of bounds.
+    /// Panics if `i` is out of bounds.
     ///
     /// # Example
     ///
@@ -353,9 +353,9 @@ impl Bitv {
     /// Sets `self` to the union of `self` and `other`. Both bitvectors must be
     /// the same length. Returns `true` if `self` changed.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the bitvectors are of different lengths.
+    /// Panics if the bitvectors are of different lengths.
     ///
     /// # Example
     ///
@@ -383,9 +383,9 @@ impl Bitv {
     /// Sets `self` to the intersection of `self` and `other`. Both bitvectors
     /// must be the same length. Returns `true` if `self` changed.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the bitvectors are of different lengths.
+    /// Panics if the bitvectors are of different lengths.
     ///
     /// # Example
     ///
@@ -413,9 +413,9 @@ impl Bitv {
     /// element of `other` at the same index. Both bitvectors must be the same
     /// length. Returns `true` if `self` changed.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the bitvectors are of different length.
+    /// Panics if the bitvectors are of different length.
     ///
     /// # Example
     ///
@@ -580,9 +580,9 @@ impl Bitv {
     /// Compares a `Bitv` to a slice of `bool`s.
     /// Both the `Bitv` and slice must have the same length.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the the `Bitv` and slice are of different length.
+    /// Panics if the the `Bitv` and slice are of different length.
     ///
     /// # Example
     ///
@@ -718,7 +718,7 @@ impl Bitv {
 
     /// Shortens by one element and returns the removed element.
     ///
-    /// # Failure
+    /// # Panics
     ///
     /// Assert if empty.
     ///

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

@@ -498,9 +498,9 @@ impl String {
 
     /// Shortens a string to the specified length.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `new_len` > current length,
+    /// Panics if `new_len` > current length,
     /// or if `new_len` is not a character boundary.
     ///
     /// # Example

branches/snap-stage3/src/libcollections/tree/set.rs

@@ -504,9 +504,9 @@ impl<T: Ord> TreeSet<T> {
     /// # Example
     ///
     /// ```
-    /// use std::collections::BTreeSet;
+    /// use std::collections::TreeSet;
     ///
-    /// let mut set = BTreeSet::new();
+    /// let mut set = TreeSet::new();
     ///
     /// assert_eq!(set.insert(2i), true);
     /// assert_eq!(set.insert(2i), false);
@@ -522,9 +522,9 @@ impl<T: Ord> TreeSet<T> {
     /// # Example
     ///
     /// ```
-    /// use std::collections::BTreeSet;
+    /// use std::collections::TreeSet;
     ///
-    /// let mut set = BTreeSet::new();
+    /// let mut set = TreeSet::new();
     ///
     /// set.insert(2i);
     /// assert_eq!(set.remove(&2), true);

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

@@ -941,9 +941,9 @@ impl<T> Vec<T> {
 
     /// Appends an element to the back of a collection.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the number of elements in the vector overflows a `uint`.
+    /// Panics if the number of elements in the vector overflows a `uint`.
     ///
     /// # Example
     ///
@@ -1462,9 +1462,9 @@ impl<T> Vec<T> {
     /// Converts a `Vec<T>` to a `Vec<U>` where `T` and `U` have the same
     /// size and in case they are not zero-sized the same minimal alignment.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `T` and `U` have differing sizes or are not zero-sized and
+    /// Panics if `T` and `U` have differing sizes or are not zero-sized and
     /// have differing minimal alignments.
     ///
     /// # Example

branches/snap-stage3/src/libcore/atomic.rs

@@ -102,19 +102,19 @@ impl AtomicBool {
 
     /// Load the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Release` or `AcqRel`.
+    /// Panics if `order` is `Release` or `AcqRel`.
     #[inline]
     pub fn load(&self, order: Ordering) -> bool {
         unsafe { atomic_load(self.v.get() as *const uint, order) > 0 }
     }
 
     /// Store the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Acquire` or `AcqRel`.
+    /// Panics if `order` is `Acquire` or `AcqRel`.
     #[inline]
     pub fn store(&self, val: bool, order: Ordering) {
         let val = if val { UINT_TRUE } else { 0 };
@@ -313,19 +313,19 @@ impl AtomicInt {
 
     /// Load the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Release` or `AcqRel`.
+    /// Panics if `order` is `Release` or `AcqRel`.
     #[inline]
     pub fn load(&self, order: Ordering) -> int {
         unsafe { atomic_load(self.v.get() as *const int, order) }
     }
 
     /// Store the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Acquire` or `AcqRel`.
+    /// Panics if `order` is `Acquire` or `AcqRel`.
     #[inline]
     pub fn store(&self, val: int, order: Ordering) {
         unsafe { atomic_store(self.v.get(), val, order); }
@@ -435,19 +435,19 @@ impl AtomicUint {
 
     /// Load the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Release` or `AcqRel`.
+    /// Panics if `order` is `Release` or `AcqRel`.
     #[inline]
     pub fn load(&self, order: Ordering) -> uint {
         unsafe { atomic_load(self.v.get() as *const uint, order) }
     }
 
     /// Store the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Acquire` or `AcqRel`.
+    /// Panics if `order` is `Acquire` or `AcqRel`.
     #[inline]
     pub fn store(&self, val: uint, order: Ordering) {
         unsafe { atomic_store(self.v.get(), val, order); }
@@ -557,9 +557,9 @@ impl<T> AtomicPtr<T> {
 
     /// Load the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Release` or `AcqRel`.
+    /// Panics if `order` is `Release` or `AcqRel`.
     #[inline]
     pub fn load(&self, order: Ordering) -> *mut T {
         unsafe {
@@ -569,9 +569,9 @@ impl<T> AtomicPtr<T> {
 
     /// Store the value
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `order` is `Acquire` or `AcqRel`.
+    /// Panics if `order` is `Acquire` or `AcqRel`.
     #[inline]
     pub fn store(&self, ptr: *mut T, order: Ordering) {
         unsafe { atomic_store(self.p.get(), ptr as uint, order); }
@@ -729,9 +729,9 @@ unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
 ///
 /// Accepts `Acquire`, `Release`, `AcqRel` and `SeqCst` orderings.
 ///
-/// # Failure
+/// # Panics
 ///
-/// Fails if `order` is `Relaxed`
+/// Panics if `order` is `Relaxed`
 #[inline]
 #[stable]
 pub fn fence(order: Ordering) {

branches/snap-stage3/src/libcore/cell.rs

@@ -282,9 +282,9 @@ impl<T> RefCell<T> {
     /// The borrow lasts until the returned `Ref` exits scope. Multiple
     /// immutable borrows can be taken out at the same time.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the value is currently mutably borrowed.
+    /// Panics if the value is currently mutably borrowed.
     #[unstable]
     pub fn borrow<'a>(&'a self) -> Ref<'a, T> {
         match self.try_borrow() {
@@ -315,9 +315,9 @@ impl<T> RefCell<T> {
     /// The borrow lasts until the returned `RefMut` exits scope. The value
     /// cannot be borrowed while this borrow is active.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the value is currently borrowed.
+    /// Panics if the value is currently borrowed.
     #[unstable]
     pub fn borrow_mut<'a>(&'a self) -> RefMut<'a, T> {
         match self.try_borrow_mut() {