---

yaml
---
r: 110171
b: refs/heads/auto
c: d9a1af2
h: refs/heads/master
i:
  110169: f76f72c
  110167: f04f801
v: v3

Author: Ms2ger

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 94a055c7295bd5822219b86243c2af6fff9d21d3
+refs/heads/auto: d9a1af27419d866500db00a204854d708553a320
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/rust.md

@@ -206,12 +206,13 @@ The keywords are the following strings:
 as
 break
 crate
+do
 else enum extern
 false fn for
 if impl in
 let loop
 match mod mut
-priv proc pub
+priv pub
 ref return
 self static struct super
 true trait type
@@ -2557,12 +2558,12 @@ task in a _failing state_.
 
 ~~~~ {.ignore}
 # use std::task;
-# task::spawn(proc() {
+# do task::spawn {
 
 ([1, 2, 3, 4])[0];
 (["a", "b"])[10]; // fails
 
-# })
+# }
 ~~~~
 
 ### Unary operator expressions

branches/auto/src/doc/rustdoc.md

@@ -165,12 +165,12 @@ that one can still write things like `#[deriving(Eq)]`).
     # // what's actually being documented.
     # fn fib(n: int) { n + 2 }
 
-    spawn(proc() { fib(200); })
+    do spawn { fib(200); }
     ```
     */
     # fn foo() {}
 
-The documentation online would look like `spawn(proc() { fib(200); })`, but when
+The documentation online would look like `do spawn { fib(200); }`, but when
 testing this code, the `fib` function will be included (so it can compile).
 
 ## Running tests (advanced)

branches/auto/src/doc/tutorial.md

@@ -1492,8 +1492,8 @@ Rust uses the unary star operator (`*`) to access the contents of a
 box or pointer, similarly to C.
 
 ~~~
-let owned = ~10;
-let borrowed = &20;
+let owned = ~20;
+let borrowed = &30;
 
 let sum = *owned + *borrowed;
 ~~~
@@ -1520,7 +1520,7 @@ can sometimes make code awkward and parenthesis-filled.
 # struct Point { x: f64, y: f64 }
 # enum Shape { Rectangle(Point, Point) }
 # impl Shape { fn area(&self) -> int { 0 } }
-let start = ~Point { x: 10.0, y: 20.0 };
+let start = @Point { x: 10.0, y: 20.0 };
 let end = ~Point { x: (*start).x + 100.0, y: (*start).y + 100.0 };
 let rect = &Rectangle(*start, *end);
 let area = (*rect).area();
@@ -1534,7 +1534,7 @@ dot), so in most cases, explicitly dereferencing the receiver is not necessary.
 # struct Point { x: f64, y: f64 }
 # enum Shape { Rectangle(Point, Point) }
 # impl Shape { fn area(&self) -> int { 0 } }
-let start = ~Point { x: 10.0, y: 20.0 };
+let start = @Point { x: 10.0, y: 20.0 };
 let end = ~Point { x: start.x + 100.0, y: start.y + 100.0 };
 let rect = &Rectangle(*start, *end);
 let area = rect.area();
@@ -1546,7 +1546,7 @@ something silly like
 
 ~~~
 # struct Point { x: f64, y: f64 }
-let point = &~Point { x: 10.0, y: 20.0 };
+let point = &@~Point { x: 10.0, y: 20.0 };
 println!("{:f}", point.x);
 ~~~
 
@@ -1907,6 +1907,7 @@ to a reference.
 // As with typical function arguments, owned pointers
 // are automatically converted to references
 
+(@s).draw_reference();
 (~s).draw_reference();
 
 // Unlike typical function arguments, the self value will
@@ -1917,7 +1918,7 @@ s.draw_reference();
 (& &s).draw_reference();
 
 // ... and dereferenced and borrowed
-(&~s).draw_reference();
+(&@~s).draw_reference();
 ~~~
 
 Implementations may also define standalone (sometimes called "static")
@@ -2402,7 +2403,7 @@ that, like strings and vectors, objects have dynamic size and may
 only be referred to via one of the pointer types.
 Other pointer types work as well.
 Casts to traits may only be done with compatible pointers so,
-for example, an `&Circle` may not be cast to an `~Drawable`.
+for example, an `@Circle` may not be cast to an `~Drawable`.
 
 ~~~
 # type Circle = int; type Rectangle = int;
@@ -2505,8 +2506,8 @@ use std::f64::consts::PI;
 # impl Circle for CircleStruct { fn radius(&self) -> f64 { (self.area() / PI).sqrt() } }
 # impl Shape for CircleStruct { fn area(&self) -> f64 { PI * square(self.radius) } }
 
-let concrete = ~CircleStruct{center:Point{x:3.0,y:4.0},radius:5.0};
-let mycircle: ~Circle = concrete as ~Circle;
+let concrete = @CircleStruct{center:Point{x:3.0,y:4.0},radius:5.0};
+let mycircle: @Circle = concrete as @Circle;
 let nonsense = mycircle.radius() * mycircle.area();
 ~~~
 

branches/auto/src/librustc/driver/driver.rs

@@ -323,9 +323,6 @@ pub fn phase_3_run_analysis_passes(sess: Session,
     let region_map = time(time_passes, "region resolution", (), |_|
                           middle::region::resolve_crate(&sess, krate));
 
-    time(time_passes, "loop checking", (), |_|
-         middle::check_loop::check_crate(&sess, krate));
-
     let ty_cx = ty::mk_ctxt(sess, def_map, named_region_map, ast_map,
                             freevars, region_map, lang_items);
 
@@ -351,6 +348,9 @@ pub fn phase_3_run_analysis_passes(sess: Session,
     time(time_passes, "effect checking", (), |_|
          middle::effect::check_crate(&ty_cx, method_map, krate));
 
+    time(time_passes, "loop checking", (), |_|
+         middle::check_loop::check_crate(&ty_cx, krate));
+
     let middle::moves::MoveMaps {moves_map, moved_variables_set,
                                  capture_map} =
         time(time_passes, "compute moves", (), |_|

branches/auto/src/librustc/middle/check_loop.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use driver::session::Session;
+use middle::ty;
 
 use syntax::ast;
 use syntax::codemap::Span;
@@ -21,11 +21,11 @@ enum Context {
 }
 
 struct CheckLoopVisitor<'a> {
-    sess: &'a Session,
+    tcx: &'a ty::ctxt,
 }
 
-pub fn check_crate(sess: &Session, krate: &ast::Crate) {
-    visit::walk_crate(&mut CheckLoopVisitor { sess: sess }, krate, Normal)
+pub fn check_crate(tcx: &ty::ctxt, krate: &ast::Crate) {
+    visit::walk_crate(&mut CheckLoopVisitor { tcx: tcx }, krate, Normal)
 }
 
 impl<'a> Visitor<Context> for CheckLoopVisitor<'a> {
@@ -57,10 +57,12 @@ impl<'a> CheckLoopVisitor<'a> {
         match cx {
             Loop => {}
             Closure => {
-                self.sess.span_err(span, format!("`{}` inside of a closure", name));
+                self.tcx.sess.span_err(span, format!("`{}` inside of a closure",
+                                                     name));
             }
             Normal => {
-                self.sess.span_err(span, format!("`{}` outside of loop", name));
+                self.tcx.sess.span_err(span, format!("`{}` outside of loop",
+                                                     name));
             }
         }
     }

branches/auto/src/librustc/middle/typeck/check/mod.rs

@@ -923,7 +923,7 @@ fn compare_impl_method(tcx: &ty::ctxt,
         result::Err(ref terr) => {
             tcx.sess.span_err(
                 impl_m_span,
-                format!("method `{}` has an incompatible type for trait: {}",
+                format!("method `{}` has an incompatible type: {}",
                         token::get_ident(trait_m.ident),
                         ty::type_err_to_str(tcx, terr)));
             ty::note_and_explain_type_err(tcx, terr);

branches/auto/src/libsemver/lib.rs

@@ -79,17 +79,17 @@ impl fmt::Show for Identifier {
 #[deriving(Clone)]
 pub struct Version {
     /// The major version, to be incremented on incompatible changes.
-    major: uint,
+    pub major: uint,
     /// The minor version, to be incremented when functionality is added in a
     /// backwards-compatible manner.
-    minor: uint,
+    pub minor: uint,
     /// The patch version, to be incremented when backwards-compatible bug
     /// fixes are made.
-    patch: uint,
+    pub patch: uint,
     /// The pre-release version identifier, if one exists.
-    pre: Vec<Identifier>,
+    pub pre: Vec<Identifier>,
     /// The build metadata, ignored when determining version precedence.
-    build: Vec<Identifier>,
+    pub build: Vec<Identifier>,
 }
 
 impl fmt::Show for Version {