---

yaml
---
r: 139341
b: refs/heads/try2
c: b07b36b
h: refs/heads/master
i:
  139339: d831a49
v: v3

Author: pcwalton

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

branches/try2/doc/rust.md

@@ -830,12 +830,12 @@ An example of re-exporting:
 ~~~~
 # fn main() { }
 mod quux {
+    pub use quux::foo::*;
+
     pub mod foo {
         pub fn bar() { }
         pub fn baz() { }
     }
-
-    pub use quux::foo::*;
 }
 ~~~~
 
@@ -2008,8 +2008,8 @@ then the expression completes.
 Some examples of call expressions:
 
 ~~~~
-# fn add(x: int, y: int) -> int { 0 }
 # use core::from_str::FromStr::from_str;
+# fn add(x: int, y: int) -> int { 0 }
 
 let x: int = add(1, 2);
 let pi = from_str::<f32>("3.14");

branches/try2/doc/tutorial.md

@@ -2054,9 +2054,9 @@ name and a double colon.  The compiler uses type inference to decide which
 implementation to use.
 
 ~~~~
-trait Shape { fn new(area: float) -> Self; }
 # use core::float::consts::pi;
 # use core::float::sqrt;
+trait Shape { fn new(area: float) -> Self; }
 struct Circle { radius: float }
 struct Square { length: float }
 
@@ -2211,11 +2211,11 @@ trait Circle : Shape { fn radius(&self) -> float; }
 Now, we can implement `Circle` on a type only if we also implement `Shape`.
 
 ~~~~
+# use core::float::consts::pi;
+# use core::float::sqrt;
 # trait Shape { fn area(&self) -> float; }
 # trait Circle : Shape { fn radius(&self) -> float; }
 # struct Point { x: float, y: float }
-# use core::float::consts::pi;
-# use core::float::sqrt;
 # fn square(x: float) -> float { x * x }
 struct CircleStruct { center: Point, radius: float }
 impl Circle for CircleStruct {
@@ -2247,10 +2247,10 @@ fn radius_times_area<T: Circle>(c: T) -> float {
 Likewise, supertrait methods may also be called on trait objects.
 
 ~~~ {.xfail-test}
-# trait Shape { fn area(&self) -> float; }
-# trait Circle : Shape { fn radius(&self) -> float; }
 # use core::float::consts::pi;
 # use core::float::sqrt;
+# trait Shape { fn area(&self) -> float; }
+# trait Circle : Shape { fn radius(&self) -> float; }
 # struct Point { x: float, y: float }
 # struct CircleStruct { center: Point, radius: float }
 # impl Circle for CircleStruct { fn radius(&self) -> float { sqrt(self.area() / pi) } }

branches/try2/src/test/auxiliary/pub_use_mods_xcrate.rs

@@ -9,13 +9,13 @@
 // except according to those terms.
 
 pub mod a {
+    pub use a::b::c;
+
     pub mod b {
         pub mod c {
             fn f(){}
             fn g(){}
         }
     }
-
-    pub use a::b::c;
 }
 

branches/try2/src/test/bench/shootout-binarytrees.rs

@@ -12,7 +12,7 @@ extern mod std;
 use std::arena;
 use methods = std::arena::Arena;
 
-enum tree {
+enum tree<'self> {
     nil,
     node(&'self tree<'self>, &'self tree<'self>, int),
 }
@@ -26,9 +26,10 @@ fn item_check(t: &tree) -> int {
     }
 }
 
-fn bottom_up_tree(arena: &'r arena::Arena,
-                  item: int,
-                  depth: int) -> &'r tree<'r> {
+fn bottom_up_tree<'r>(arena: &'r arena::Arena,
+                      item: int,
+                      depth: int)
+                   -> &'r tree<'r> {
     if depth > 0 {
         return arena.alloc(
             || node(bottom_up_tree(arena, 2 * item - 1, depth - 1),

branches/try2/src/test/compile-fail/issue-4366.rs

@@ -13,6 +13,8 @@
 // ensures that 'use foo:*' doesn't import non-public 'use' statements in the
 // module 'foo'
 
+use m1::*;
+
 mod foo {
     pub fn foo() {}
 }
@@ -31,7 +33,6 @@ mod a {
 mod m1 {
     fn foo() {}
 }
-use m1::*;
 
 fn main() {
     foo(); //~ ERROR: unresolved name: `foo`

branches/try2/src/test/compile-fail/regions-in-enums.rs

@@ -10,15 +10,15 @@
 
 enum yes0<'lt> {
     // This will eventually be legal (and in fact the only way):
-    X3(&'lt uint) //~ ERROR Illegal lifetime 'lt: this lifetime must be declared
+    X3(&'lt uint) //~ ERROR Illegal lifetime 'lt: only 'self is allowed
 }
 
 enum yes1<'self> {
     X4(&'self uint)
 }
 
 enum yes2 {
-    X5(&'foo uint) //~ ERROR Illegal lifetime 'foo: this lifetime must be declared
+    X5(&'foo uint) //~ ERROR Illegal lifetime 'foo: only 'self is allowed
 }
 
 fn main() {}

branches/try2/src/test/compile-fail/regions-in-type-items.rs

@@ -17,7 +17,7 @@ struct item_ty_yes1<'self> {
 }
 
 struct item_ty_yes2 {
-    x: &'a uint //~ ERROR this lifetime must be declared
+    x: &'a uint //~ ERROR only 'self is allowed
 }
 
 fn main() {}

branches/try2/src/test/run-pass/issue-2904.rs

@@ -12,10 +12,10 @@
 
 /// Map representation
 
-use core::io::ReaderUtil;
-
 extern mod std;
 
+use core::io::ReaderUtil;
+
 enum square {
     bot,
     wall,

branches/try2/src/test/run-pass/trait-inheritance-num.rs

@@ -10,10 +10,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+extern mod std;
+
 use core::cmp::{Eq, Ord};
 use core::num::NumCast::from;
-
-extern mod std;
 use std::cmp::FuzzyEq;
 
 pub trait NumExt: NumCast + Eq + Ord {}

branches/try2/src/test/run-pass/trait-inheritance-num2.rs

@@ -12,10 +12,10 @@
 
 // A more complex example of numeric extensions
 
+extern mod std;
+
 use core::cmp::{Eq, Ord};
 use core::num::NumCast::from;
-
-extern mod std;
 use std::cmp::FuzzyEq;
 
 pub trait TypeExt {}