---

yaml
---
r: 155644
b: refs/heads/try2
c: 182044b
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 618e41874a1ef47a6629524016bd8d9ffce617bc
+refs/heads/try2: 182044b42502f59bcf3156d5092c565ebb32d59e
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/tests.mk

@@ -261,12 +261,13 @@ ALL_HS := $(filter-out $(S)src/rt/valgrind/valgrind.h \
 tidy:
 		@$(call E, check: formatting)
 		$(Q)find $(S)src -name '*.r[sc]' \
-		| grep '^$(S)src/jemalloc' -v \
-		| grep '^$(S)src/libuv' -v \
-		| grep '^$(S)src/llvm' -v \
-		| grep '^$(S)src/gyp' -v \
-		| grep '^$(S)src/libbacktrace' -v \
-		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
+		    -and -not -regex '^$(S)src/jemalloc.*' \
+		    -and -not -regex '^$(S)src/libuv.*' \
+		    -and -not -regex '^$(S)src/llvm.*' \
+		    -and -not -regex '^$(S)src/gyp.*' \
+		    -and -not -regex '^$(S)src/libbacktrace.*' \
+		    -print0 \
+		| xargs -0 -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)find $(S)src/etc -name '*.py' \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)find $(S)src/doc -name '*.js' \

branches/try2/src/compiletest/compiletest.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-#![feature(phase, slicing_syntax)]
+#![feature(phase)]
 
 #![deny(warnings)]
 

branches/try2/src/compiletest/runtest.rs

@@ -874,7 +874,7 @@ fn check_error_patterns(props: &TestProps,
     if done { return; }
 
     let missing_patterns =
-        props.error_patterns[next_err_idx..];
+        props.error_patterns.slice(next_err_idx, props.error_patterns.len());
     if missing_patterns.len() == 1u {
         fatal_proc_rec(format!("error pattern '{}' not found!",
                               missing_patterns[0]).as_slice(),

branches/try2/src/doc/guide-lifetimes.md

@@ -305,21 +305,17 @@ copying.
 #     Circle(Point, f64),   // origin, radius
 #     Rectangle(Point, Size)  // upper-left, dimensions
 # }
-# static tau: f64 = 6.28;
 fn compute_area(shape: &Shape) -> f64 {
     match *shape {
-        Circle(_, radius) => 0.5 * tau * radius * radius,
+        Circle(_, radius) => std::f64::consts::PI * radius * radius,
         Rectangle(_, ref size) => size.w * size.h
     }
 }
 ~~~
 
 The first case matches against circles. Here, the pattern extracts the
 radius from the shape variant and the action uses it to compute the
-area of the circle. (Like any up-to-date engineer, we use the [tau
-circle constant][tau] and not that dreadfully outdated notion of pi).
-
-[tau]: http://www.math.utah.edu/~palais/pi.html
+area of the circle.
 
 The second match is more interesting. Here we match against a
 rectangle and extract its size: but rather than copy the `size`

branches/try2/src/doc/guide.md

@@ -659,14 +659,12 @@ error: mismatched types: expected `int` but found `()` (expected int but found (
 ```
 
 We expected an integer, but we got `()`. `()` is pronounced 'unit', and is a
-special type in Rust's type system. `()` is different than `null` in other
-languages, because `()` is distinct from other types. For example, in C, `null`
-is a valid value for a variable of type `int`. In Rust, `()` is _not_ a valid
-value for a variable of type `int`. It's only a valid value for variables of
-the type `()`, which aren't very useful. Remember how we said statements don't
-return a value? Well, that's the purpose of unit in this case. The semicolon
-turns any expression into a statement by throwing away its value and returning
-unit instead.
+special type in Rust's type system. In Rust, `()` is _not_ a valid value for a
+variable of type `int`. It's only a valid value for variables of the type `()`,
+which aren't very useful. Remember how we said statements don't return a value?
+Well, that's the purpose of unit in this case. The semicolon turns any
+expression into a statement by throwing away its value and returning unit
+instead.
 
 There's one more time in which you won't see a semicolon at the end of a line
 of Rust code. For that, we'll need our next concept: functions.
@@ -1680,11 +1678,11 @@ just `int`s.
 
 Rust provides a method on these `IoResult<T>`s called `ok()`, which does the
 same thing as our `match` statement, but assuming that we have a valid value.
-If we don't, it will terminate our program. In this case, if we can't get
-input, our program doesn't work, so we're okay with that. In most cases, we
-would want to handle the error case explicitly. The result of `ok()` has a
-method, `expect()`, which allows us to give an error message if this crash
-happens.
+We then call `expect()` on the result, which will terminate our program if we
+don't have a valid value. In this case, if we can't get input, our program
+doesn't work, so we're okay with that. In most cases, we would want to handle
+the error case explicitly. `expect()` allows us to give an error message if
+this crash happens.
 
 We will cover the exact details of how all of this works later in the Guide.
 For now, this gives you enough of a basic understanding to work with.
@@ -2030,7 +2028,7 @@ fn main() {
     match cmp(input, secret_number) {
         Less    => println!("Too small!"),
         Greater => println!("Too big!"),
-        Equal   => { println!("You win!"); },
+        Equal   => println!("You win!"),
     }
 }
 
@@ -2727,7 +2725,8 @@ mod hello {
 }
 ```
 
-This will work:
+Usage of the `pub` keyword is sometimes called 'exporting', because
+we're making the function available for other modules. This will work:
 
 ```{notrust,ignore}
 $ cargo run
@@ -3291,8 +3290,7 @@ use super::times_four;
 
 Because we've made a nested module, we can import functions from the parent
 module by using `super`. Sub-modules are allowed to 'see' private functions in
-the parent. We sometimes call this usage of `use` a 're-export,' because we're
-exporting the name again, somewhere else.
+the parent.
 
 We've now covered the basics of testing. Rust's tools are primitive, but they
 work well in the simple cases. There are some Rustaceans working on building

branches/try2/src/doc/reference.md

@@ -3828,7 +3828,7 @@ type signature of `print`, and the cast expression in `main`.
 Within the body of an item that has type parameter declarations, the names of
 its type parameters are types:
 
-```ignore
+```
 fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> Vec<B> {
     if xs.len() == 0 {
        return vec![];

branches/try2/src/liballoc/heap.rs

@@ -182,9 +182,15 @@ mod imp {
 
     #[inline]
     pub unsafe fn reallocate_inplace(ptr: *mut u8, size: uint, align: uint,
-                                     _old_size: uint) -> bool {
+                                     old_size: uint) -> bool {
         let flags = align_to_flags(align);
-        je_xallocx(ptr as *mut c_void, size as size_t, 0, flags) == size as size_t
+        let new_size = je_xallocx(ptr as *mut c_void, size as size_t, 0, flags) as uint;
+        // checking for failure to shrink is tricky
+        if size < old_size {
+            usable_size(size, align) == new_size as uint
+        } else {
+            new_size >= size
+        }
     }
 
     #[inline]
@@ -250,9 +256,9 @@ mod imp {
     }
 
     #[inline]
-    pub unsafe fn reallocate_inplace(_ptr: *mut u8, _size: uint, _align: uint,
-                                     _old_size: uint) -> bool {
-        false
+    pub unsafe fn reallocate_inplace(_ptr: *mut u8, size: uint, _align: uint,
+                                     old_size: uint) -> bool {
+        size == old_size
     }
 
     #[inline]
@@ -312,9 +318,9 @@ mod imp {
     }
 
     #[inline]
-    pub unsafe fn reallocate_inplace(_ptr: *mut u8, _size: uint, _align: uint,
-                                     _old_size: uint) -> bool {
-        false
+    pub unsafe fn reallocate_inplace(_ptr: *mut u8, size: uint, _align: uint,
+                                     old_size: uint) -> bool {
+        size == old_size
     }
 
     #[inline]
@@ -335,10 +341,21 @@ mod imp {
 }
 
 #[cfg(test)]
-mod bench {
+mod test {
     extern crate test;
     use self::test::Bencher;
 
+    #[test]
+    fn basic_reallocate_inplace_noop() {
+        unsafe {
+            let size = 4000;
+            let ptr = heap::allocate(size, 8);
+            let ret = heap::reallocate_inplace(ptr, size, 8, size);
+            heap::deallocate(ptr, size, 8);
+            assert!(ret);
+        }
+    }
+
     #[bench]
     fn alloc_owned_small(b: &mut Bencher) {
         b.iter(|| {

branches/try2/src/libcollections/bitv.rs

@@ -194,7 +194,7 @@ impl Bitv {
         if start > self.storage.len() {
             start = self.storage.len();
         }
-        let mut iter = self.storage[start..].iter();
+        let mut iter = self.storage.slice_from(start).iter();
         MaskWords {
           next_word: iter.next(),
           iter: iter,

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

@@ -46,12 +46,12 @@ struct AbsEntries<T> {
 }
 
 /// An iterator over a BTreeMap's entries.
-pub struct Entries<'a, K, V> {
+pub struct Entries<'a, K: 'a, V: 'a> {
     inner: AbsEntries<Traversal<'a, K, V>>
 }
 
 /// A mutable iterator over a BTreeMap's entries.
-pub struct MutEntries<'a, K, V> {
+pub struct MutEntries<'a, K: 'a, V: 'a> {
     inner: AbsEntries<MutTraversal<'a, K, V>>
 }
 

branches/try2/src/libcollections/lib.rs

@@ -19,9 +19,8 @@
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
 
-#![allow(unknown_features)]
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
-#![feature(unsafe_destructor, import_shadowing, slicing_syntax)]
+#![feature(unsafe_destructor, import_shadowing)]
 #![no_std]
 
 #[phase(plugin, link)] extern crate core;

branches/try2/src/libcollections/ringbuf.rs

@@ -271,7 +271,7 @@ impl<T> RingBuf<T> {
     ///     *num = *num - 2;
     /// }
     /// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
-    /// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>()[], b);
+    /// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>().as_slice(), b);
     /// ```
     pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
         let start_index = raw_index(self.lo, self.elts.len(), 0);
@@ -291,7 +291,7 @@ impl<T> RingBuf<T> {
         } else {
             // Items to iterate goes from start_index to end_index:
             let (empty, elts) = self.elts.split_at_mut(0);
-            let remaining1 = elts[mut start_index..end_index];
+            let remaining1 = elts.slice_mut(start_index, end_index);
             MutItems { remaining1: remaining1,
                                  remaining2: empty,
                                  nelts: self.nelts }